package April.april27;

import April.Twenty_six.Sort_6;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;
import paixu.Sort;

import javax.management.Query;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

/*
QueryRunner数据查询操作：
    调用QueryRunner类方法query(Connection con,String sql,ResultSetHandler r,Object..params)
    ResultSetHandler r,结果集的处理方式，传递ResultSetHandler接口的实现类
    Object..params sql语句中的占位符

    注意：query方法返回值，返回的是T 泛型，具体返回值类型，跟随结果集处理方式变化
 */
public class DataSourceUtil {
    private static Connection con = JdbcUtil.getConnection();

    public static void main(String[] args) throws SQLException {
//        arrayHandler();
//        arrayHandler1();
//        beanHandler();
//        beanListHandler();
//        ColumenListHandler1();
//        scalarHandler();
//        mapHandler();
        mapListHandler();
    }


    /*
    结果集的第八种处理方，MapListHandler
    将结果集没一行存储到Map集合，键：列名，值：数据
    Map集合过多，存储到List集合中
     */
    public static void mapListHandler() throws SQLException {
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT * FROM java1";
//        返回Query，传递结果集实现类MapListHandler
//        返回值List集合，存储的是Map集合
        List<Map<String,Object>> list = qr.query(con,sql,new MapListHandler());
//        遍历集合List
        for (Map<String,Object> map : list){
            for (String p : map.keySet()){
                System.out.print(p+"   "+map.get(p));

            }
            System.out.println();
        }
    }
    /*
    结果集的第七种处理方式，MapHandler
    将结果集第一行数据，封装到Map集合中
    Map<键,值> 键：列名  值：这列的数据
     */
    public static void mapHandler()throws SQLException{
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT * FROM java1";
//        调用方法query，传递结果集实现类MapHandler
//        返回值：Map集合，Map接口实现类 ，泛型
        Map<String,Object> map = qr.query(con,sql,new MapHandler());
//        遍历Map集合
        for (String key: map.keySet()){
            System.out.println(key+"   "+map.get(key));
        }
    }
    /*
    结果集第六种处理方式i，ScanlarHandler
    对于查询后只有一种结果
     */
    public static void scalarHandler()throws SQLException{
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT count(pname) FROM product";
//        调用query，传递结果集处理实现类scalarHandler
        long count = qr.query(con,sql,new ScalarHandler<Long>());
        System.out.println(count);
    }
    /*
    结果的第五种处理方法，ColumenListHandler
    结果集，指定列的数据，存储到List集合中
    List<Object> 每个列数据类型不同
     */
    public static void ColumenListHandler1() throws SQLException {
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT * FROM product";
//        调用方法query，传递结果集实现类ColumnListHandler
//        实现类构造方法中，使用字符串的列名
        List<Object> list = qr.query(con,sql,new ColumnListHandler<Object>("pname"));
        for (Object obj: list){
            System.out.println(obj);
        }
    }

    /*
    结果集的第四种处理方法，BeanListHandler
    将数据结果集的每一行数据，封装成JavaBean对象
    多个JavaBean对象封装到List集合中
     */
    public static void beanListHandler() throws SQLException {
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT * FROM product";
//调用方法传递结果集的实现类BeanListHandler
//        BeanListHandler(Class<t> type)
        List<Sort_6> s = qr.query(con ,sql , new BeanListHandler<Sort_6>(Sort_6.class));
        for (Sort_6 b :s){
            System.out.println(b);
        }
    }
    /*
    结果集的第三种处理方法
    将结果集的第一行数据，封装成JavaBean对象
    注意：被封装成数据到JavaBean对象，Sort类必须有空参构造
     */
public static void beanHandler() throws SQLException {
    QueryRunner qr = new QueryRunner();
    String sql = "SELECT * FROM product";
//    调用方法，传递结果集实现类BeanHandler
//    BeanHandler(Class<T> type)
    Sort_6 s = qr.query(con,sql,new BeanHandler<Sort_6>(Sort_6.class));
    System.out.println(s);
}
    /*
    结果集的第二种处理方式
    将结果集的没一行，封装到对象数组中，出现很多对象数组
    将结果数组存储到List集合中
     */
    public static void arrayHandler1() throws SQLException {
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT * FROM java1";
//        调用query方法，结果集处理的参数，传递实现类ArrayListHandler
//        方法返回值 每行是一个对象数组，存储到List中
        List<Object[]> result = qr.query(con,sql,new ArrayListHandler());
        System.out.println(result.getClass());
        for (Object[] objs : result){
//            遍历对象数组
            for (Object obj : objs){
                System.out.print(obj);
            }
            System.out.println();
        }
    }

    /*
        结果集第一种处理方法，ArrayHander
        将结果的第一行存储到对象数组中 Object【】
     */
    public static void arrayHandler() throws SQLException {
        QueryRunner qr = new QueryRunner();
        String sql = "SELECT * FROM java1";
//        返回对象数组
        Object[] result = qr.query(con,sql,new ArrayHandler());
        System.out.println(result);
        for (Object obj: result){
            System.out.println(obj);
        }
    }
}
